package com.xt.base.wireless.util;

import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;

/**
 * <br>
 * <br>
 * 
 * <p>
 * <a href="ByteCoding.java.html"><i>查看源文件</i></a>
 * </p>
 * 
 * @author 杨洪波
 * @create-date:2010-10-13
 */
public class ByteCoding {
	
	/**
	 * 将字节数组转换为整形。
	 * @param _byte 被
	 * @return
	 */
	public static int decode4Byte(byte[] _byte) {
		int b1 = (_byte[0] >= 0) ? (_byte[0] << 24) : (_byte[0] << 24) + 256;
		int b2 = (_byte[1] >= 0) ? (_byte[1] << 16) : (_byte[1] << 16) + 256;
		int b3 = (_byte[2] >= 0) ? (_byte[2] << 8) : (_byte[2] << 8) + 256;
		int b4 = (_byte[3] >= 0) ? _byte[3] : (_byte[3] + 256);
		return b1 | b2 | b3 | b4;
	}
	
	public static int decode4Byte(InputStream is) {
		byte[] b = new byte[4];
		try {
			is.read(b);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return decode4Byte(b);
	}

	/**
	 * 将整形转换为字节数组
	 * @param i 整形，为需要传输的二进制数据的长度
	 * @return
	 */
	public static byte[] encode4Byte(int i) {
		byte[] _byte = new byte[4]; // int在内存占四个字节；把这四个字节取出来存在数组中
		_byte[0] = (byte) (i >> 24); // 丢弃后三字节,取第一字节.
		_byte[1] = (byte) (i << 8 >> 24); // 去掉第一字节,丢弃后两字节,取第二字节,
		_byte[2] = (byte) (i << 16 >> 24); // 去掉前二字节,丢弃后一字节,取第三字节,
		_byte[3] = (byte) (i << 24 >> 24); // 去掉前三字节,取第四字节。
		return _byte;
	}
	
	/**
	 * 将字符串及其长度，封装到一个字节数组中。默认字符集为<code>utf-8</code>
	 * @param s 字符串
	 * @return
	 */
	public static byte[] encodeString2Bytes(String s){
		return encodeString2Bytes(s,"UTF-8");
	}
	/**
	 * 将字符串及其长度，封装到一个字节数组中。
	 * @param s 字符串
	 * @param charsetName 字符集名称
	 * @return
	 */
	public static byte[] encodeString2Bytes(String s,String charsetName){
		byte[] bytes=null;
		try {
			bytes = s.getBytes(charsetName);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
    	int size = bytes.length;
    	byte[] intByte = ByteCoding.encode4Byte(size);
    	byte[] bs = new byte[size+intByte.length];
    	System.arraycopy(intByte, 0, bs, 0, intByte.length);
    	System.arraycopy(bytes, 0, bs, intByte.length, size);
		
		return bs;
	}
	/**
	 * 将带有字符串长度的输入流，转换成字符串。默认字符集为<code>utf-8</code>
	 * @param bytes 带有字符串长度的字节数组。
	 * @return
	 */
	public static String decodeBytes2String(InputStream is){
		byte[] intByte = new byte[4];
		try {
			is.read(intByte);
		} catch (IOException e) {
			e.printStackTrace();
		}
		int size = decode4Byte(intByte);
		return decodeBytes2String(is,size,"utf-8");
	}
	/**
	 * 将带有字符串长度的输入流，转换成字符串。
	 * @param bytes 带有字符串长度的字节数组。
	 * @param charsetName 字符集名称
	 * @return
	 */
	/*public static String decodeBytes2String(InputStream is,String charsetName){
		String s = "connectionIsBaded";
		try {
			byte[] intByte = new byte[4];
			is.read(intByte);
			int size = decode4Byte(intByte);
			System.out
					.println("ByteCoding.decodeBytes2String::package head size="
							+ size);
			if (size < 0) {
				return null;
			}

			byte[] sBytes = new byte[size];
			is.read(sBytes);
			s = new String(sBytes, charsetName);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		return s;
	}*/
	public static String decodeBytes2String(InputStream is,int pkgSize){
		return decodeBytes2String(is,pkgSize,"UTF-8");
	}
	/**
	 * 将带有字符串长度的输入流，转换成字符串。
	 * @param bytes 带有字符串长度的字节数组。
	 * @param pkgSize 将要取出的包大小
	 * @param charsetName 字符集名称
	 * @return
	 */
	public static String decodeBytes2String(InputStream is,int pkgSize,String charsetName){
		String s = "connectionIsBaded";
		try {
			byte[] sBytes = new byte[pkgSize];
			is.read(sBytes);
			s = new String(sBytes, charsetName);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		return s;
	}
	
	
	/**
	 * 当传的内容为二进制文件时，需要将此文件转换为附带有长度字节数组。
	 * @param byteFile
	 * @return
	 */
	public static byte[] encodeByteFile2Bytes(byte[] byteFile){
    	int size = byteFile.length;
    	byte[] intByte = ByteCoding.encode4Byte(size);
    	byte[] bs = new byte[size+intByte.length];
    	System.arraycopy(intByte, 0, bs, 0, intByte.length);
    	System.arraycopy(byteFile, 0, bs, intByte.length, size);
		return bs;
	}
	/**
	 * 从附带有长度的输入流中，读取二进制文件，以字节数组方式返回。
	 * @param is 输入流
	 * @return
	 */
	public static byte[] decodeBytes2ByteFile(InputStream is){
		byte[] byteFile = null;
		try {
			byte[] intByte = new byte[4];
			is.read(intByte);
			int size = decode4Byte(intByte);
			
			if(size<0){
				System.out.println("ByteCoding.decodeBytes2ByteFile::package head size="+size);
				return new byte[0];
			}
			
			byteFile = new byte[size];
			is.read(byteFile);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return byteFile;
	}
	
	/**
	 * 判断传输过来的数据格式。当返回1 --传输过来的数据为字符串，
	 * 2 --传输过来的数据为二进制文件，其他 --没有指定数据格式。
	 * @param is 带有数据格式的输入流。
	 * @return
	 */
	public static byte decodeDataType(InputStream is){
		byte[] headByte = new byte[1];
		try {
			is.read(headByte);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return headByte[0];
	}
	
	public static void arrayCopy(byte[] org,int orgOffset,byte[] dest,
			int destOffSet,int copyArraySize){
	}
}
